{
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "# 变分量子精密测量"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<em> Copyright (c) 2022 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. </em>"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## 概览"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "量子精密测量通过利用量子理论（如量子纠缠）来研究如何高精度和高灵敏度测量物理参数，其理论方面为量子参数估计理论，应用方面为量子传感。已有研究表明，利用量子理论估计的参数精度相较于经典方法有开根号的提升 [1-3]。对于一个未知参数，量子精密测量的目标就是最大化参数估计精度的同时最小化所需要的资源（如时间、量子比特数等）。\n",
                "\n",
                "例如，给定一个酉算子 $e^{-i\\phi H}$，其中 $H$ 是给定的哈密顿量，那么如何用量子精密测量的方法估计未知参数 $\\phi$ 呢？主要包括以下四步：\n",
                "1. 初始化：制备系统初始输入态 $|\\psi\\rangle$;\n",
                "2. 参数化：输入态在 $e^{-i\\phi H}$ 的演化下得到参数化的量子态 $e^{-i\\phi H}|\\psi\\rangle$；\n",
                "3. 测量：测量输入态经过含有未知参数演化后得到的输出态；\n",
                "4. 经典估计：根据多次测量的结果估计未知参数的值。\n",
                "\n",
                "结合量子参数估计理论的知识，本教程根据 [4] 中变分量子传感的思想，利用量桨构建变分量子电路训练损失函数，得到能够估计服从正态分布的参数的传感器，即优化后的量子电路。"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## 参数估计理论"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### 经典参数估计"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "经典参数估计，如最大似然估计（maximum-likelihood estimator, MLE），通过利用多个样本来计算包含未知参数信息的数据，即给定一个含有未知参数 $\\phi$ 的概率分布，$f$ 为概率密度函数，${\\bf X}=\\{X_1,X_2,...,X_N\\}$ 为 $N$ 个独立同分布的样本数据，利用 MLE 得到 $\\phi$ 的估计值 $\\hat\\phi$：\n",
                "\n",
                "$$\n",
                "\\hat\\phi({\\bf X})=\\arg\\max_{\\phi}\\prod_i^Nf(X_i,\\phi), \\tag{1}\n",
                "$$\n",
                "\n",
                "即求一个 $\\phi$ 使得 $X_i(i=1,...,N)$ 同时出现的概率最大。在得到估计的参数后，如何衡量估计得到的参数与实际参数的差距呢？即如何衡量估计参数的精度？参数估计理论中一般利用均方误差（mean squared error, MSE）来衡量这一精度。\n",
                "\n",
                "含有未知参数 $\\bf{\\phi}$ 的样本为 ${\\bf{X}}=\\{X_1,X_2,...,X_N\\}\\in \\mathcal F^N$，${\\mathcal F}^N$ 为样本空间，假设 $\\hat{\\phi}({\\bf X}):{\\mathcal F}^N\\rightarrow\\Phi$ 为估计 $\\phi\\in\\Phi$ 的估计器（$\\Phi$ 为参数空间），则 $\\hat{\\phi}({\\bf X})$ 关于 $\\phi$ 的均方误差定义为\n",
                "\n",
                "$$\n",
                "\\begin{aligned}\n",
                "\\rm{MSE}&=E[(\\hat{\\phi}({\\bf X})-\\phi)^2]\\\\\n",
                "&=\\sum_{{\\bf X}\\in {\\mathcal F}^N}f({\\bf X};\\phi)(\\hat{\\phi}({\\bf X})-\\phi)^2, \\tag{2}\n",
                "\\end{aligned}\n",
                "$$\n",
                "\n",
                "其中 $f({\\bf X};\\phi)$ 为给定参数后的得到当前样本 $\\bf X$ 的概率密度。尽管不同的估计器会影响 MSE 的值，但不论 $\\hat{\\phi}({\\bf X})$ 的选择如何，都有 ${\\rm{MSE}}\\geq\\frac{1}{N{\\mathcal I}(\\phi)}$，该式被称为 Cramér–Rao (CR) 界 [2]，其中 ${\\mathcal I}(\\phi)$ 为费舍信息，用于描述参数变化对分布影响的物理量（关于费舍信息在量桨上的应用可参见教程[量子费舍信息](https://qml.baidu.com/tutorials/qnn-research/quantum-fisher-information.html)）。"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### 量子参数估计"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "在量子参数估计中，经典参数估计中利用的一组样本变成了待测的量子态 $\\rho_{\\phi}\\in{\\mathcal F}({\\mathcal H})$，其中 $\\phi$ 为未知参数，${\\mathcal F}({\\mathcal H})$ 表示希尔伯特空间 $\\mathcal H$ 上的密度算子集。根据量子精密测量的四步及文献 [4]，假设初始输入态为 $|0\\rangle$，估计器为 $\\hat{\\phi}(m)$（$m$ 与测量结果有关，例如为测量得到的比特串中 1 和 0 的个数差），其关于待估计参数 $\\phi$ 的均方误差为\n",
                "\n",
                "$$\n",
                "\\begin{aligned}\n",
                "{\\rm MSE}&=E[(\\hat{\\phi}(m)-\\phi)^2]\\\\\n",
                "&=\\sum_m(\\hat{\\phi}(m)-\\phi)^2p(m|\\phi),\n",
                "\\end{aligned} \\tag{3}\n",
                "$$\n",
                "\n",
                "其中 $p(m|\\phi)$ 为给定参数 $\\phi$ 时测量得到 $m$ 的概率。同样的，不论 $\\hat{\\phi}(m)$ 如何选择，有量子 CR 界 ${\\rm{MSE}}\\geq\\frac{1}{NF(\\phi)}$，其中 $N$ 为重复测量 $\\rho_\\phi$ 的次数，$F(\\phi)$ 为量子费舍信息（关于量子费舍信息在量桨上的应用可参见教程[量子费舍信息](https://qml.baidu.com/tutorials/qnn-research/quantum-fisher-information.html)）。"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## 变分量子传感"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "量子传感属于量子精密测量的应用，本教程依据文献 [4]，主要介绍一类变分拉姆塞干涉仪。传统的拉姆塞干涉仪 [2]（如图 1）是一种利用磁共振现象测量粒子跃迁频率的粒子干涉测量法，被用于测量未知参数；变分拉姆塞干涉仪 [6]（如图 2）是在电路编码和解码部分设置两个参数化量子电路（记为 $U_{\\rm{En}}(\\theta_{\\rm En}), U_{\\rm{De}}(\\theta_{\\rm{De}})$），用于设置纠缠和测量量子态。已有研究表明，结合量子理论（如量子纠缠），估计参数的精度由 $O(\\frac{1}{\\sqrt N})$ 提高到 $O(\\frac{1}{N})$ [1-3]，而通过变分的方式可以有效地找到合适的纠缠方式。\n",
                "\n",
                "![Ramsey_interferomertry](./figures/QM-fig-RI.png \"图1：拉姆塞干涉仪。\")\n",
                "\n",
                "图 1 所示为拉姆塞干涉仪估计参数的过程 [2]。左图是拉姆塞干涉仪的经典设定方式，右图为使用了量子纠缠的拉姆塞干涉仪。相比于经典设定，使用量子纠缠后的干涉仪在估计未知参数的精度上有开根号的优势。\n",
                "\n",
                "![V_Ramsey_interferomertry](./figures/QM-fig-V_RI3.png \"图2：变分拉姆塞干涉仪。\")\n",
                "\n",
                "图 2 所示为变分拉姆塞干涉仪。其中两个参数化量子电路通过优化找到电路有效的纠缠方式。\n",
                "\n",
                "下面我们利用量桨搭建参数化量子电路，来研究利用变分拉姆塞干涉仪估计的服从正态分布的参数的精度。主要分为以下三步：\n",
                "1. 初始化；\n",
                "2. 评估；\n",
                "3. 优化。\n",
                "\n",
                "参数服从的正态分布的概率密度函数为：\n",
                "\n",
                "$$\n",
                "f(x)=\\frac{1}{\\sqrt{2\\pi}\\nu}\\exp(-\\frac{(x-\\mu)^2}{2\\nu^2}), \\tag{4}\n",
                "$$\n",
                "\n",
                "$\\mu$ 为均值，$\\nu^2$ 为方差。此时变分拉姆塞干涉仪的损失函数为：\n",
                "\n",
                "$$\n",
                "C(\\theta_{\\rm En},\\theta_{\\rm De},a)=\\int d\\phi f(\\phi){\\rm{MSE}}(\\phi), \\tag{5}\n",
                "$$\n",
                "\n",
                "其中选择的估计器为 $\\hat\\phi(m)=am$，$a$ 为需要优化的参数，$m$ 为测量得到的比特串中 1 和 0 的个数差，MSE 为 ${\\rm MSE}(\\phi)=\\sum_m(\\hat{\\phi}(m)-\\phi)^2p_{\\theta}(m|\\phi)$，$\\theta=(\\theta_{\\rm En},\\theta_{\\rm De})$。"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### 1. 初始化"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "- 设置 $|0\\rangle$ 为初始输入态；\n",
                "- 设置编码和解码部分的参数化量子电路 $U_{\\rm{En}}，U_{\\rm{De}}$；\n",
                "- 将未知参数编码至电路中。"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "我们在量桨中实现上述过程，首先引入需要的包："
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 1,
            "metadata": {
                "ExecuteTime": {
                    "end_time": "2022-11-04T07:07:36.541872Z",
                    "start_time": "2022-11-04T07:07:32.740301Z"
                }
            },
            "outputs": [],
            "source": [
                "import numpy as np\n",
                "from math import exp, pi\n",
                "import matplotlib.pyplot as plt\n",
                "from typing import Optional, Tuple, List\n",
                "\n",
                "import paddle\n",
                "import paddle_quantum as pq\n",
                "from paddle_quantum.ansatz import Circuit\n",
                "from paddle_quantum.loss import Measure\n",
                "\n",
                "pq.set_backend('state_vector')\n",
                "pq.set_dtype('complex128')"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "接下来我们构建 $N$ 量子比特的参数化量子电路完成初始化操作。\n",
                "<!-- 其中未知参数服从正态分布，其概率密度函数为：\n",
                "$$\n",
                "f(x)=\\frac{1}{\\sqrt{(2\\pi)}\\sigma}exp(-\\frac{(x-\\mu)^2}{2\\sigma^2}),\n",
                "$$\n",
                "本教程中，我们选择 $\\mu=0,\\sigma=1$。 -->\n",
                "整个电路包括以下五部分：\n",
                "- $R_y^{\\otimes N}(\\frac{\\pi}{2})$ 门；\n",
                "- 编码电路 $U_{\\rm{En}}(\\theta_{\\rm{En}})$；\n",
                "- 含有未知参数的 $R_z^{\\otimes N}(\\phi)=e^{-i\\phi J_z}$，其中 $J_z=\\frac{1}{2}\\sum_{k=1}^N\\sigma_z^{(k)}$， $\\sigma_z^{(k)}$ 表示作用在第 $k$ 个量子比特上的泡利 $Z$ 算符；\n",
                "- 解码电路 $U_{\\rm{De}}(\\theta_{\\rm{De}})$；\n",
                "- $R_x^{\\otimes N}(\\frac{\\pi}{2})$ 门。\n",
                "\n",
                "因此整个电路的酉算子可以由\n",
                "$$\n",
                "U(\\phi,\\theta_{\\rm{En}},\\theta_{\\rm{De}})=R_x^{\\otimes N}(\\frac{\\pi}{2})U_{\\rm{De}}(\\theta_{\\rm{De}})R_z^{\\otimes N}(\\phi)U_{\\rm{En}}(\\theta_{\\rm{En}})R_y^{\\otimes N}(\\frac{\\pi}{2}) \\tag{6}\n",
                "$$\n",
                "来表示，当编码电路和解码电路的电路层数为 $0$ 时，此时的电路即为经典设定下的拉姆塞干涉仪。下面我们搭建编码和解码电路。"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "metadata": {
                "ExecuteTime": {
                    "end_time": "2022-11-04T07:07:36.557814Z",
                    "start_time": "2022-11-04T07:07:36.544862Z"
                }
            },
            "outputs": [],
            "source": [
                "def RamseyCircuit(theta_EN: paddle.Tensor, theta_DE: paddle.Tensor, input_phi: float) -> Circuit:\n",
                "    r\"\"\" 构建拉姆塞干涉仪的变分电路\n",
                "    \n",
                "    Args:\n",
                "        theta_EN: 编码层参数, shape 为 [编码层深度，比特数，3]\n",
                "        theta_DE: 解码层参数, shape 为 [解码层深度，比特数，3]\n",
                "        input_phi: 未知参数输入\n",
                "    \n",
                "    Returns:\n",
                "        创建完成的参数化量子电路\n",
                "    \n",
                "    \"\"\"\n",
                "    depth_EN, depth_DE = theta_EN.shape[0], theta_DE.shape[0]\n",
                "    num_qubits = theta_EN.shape[1]\n",
                "    \n",
                "    cir = Circuit(num_qubits)\n",
                "    cir.ry(param=pi/2)\n",
                "    \n",
                "    # 搭建编码电路，生成存在纠缠的输入态\n",
                "    for depth in range(depth_EN):\n",
                "        cir.u3(param=theta_EN[depth])\n",
                "        cir.cnot()\n",
                "    \n",
                "    # 未知参数门\n",
                "    cir.rz(param=input_phi)\n",
                "    \n",
                "    # 搭建解码电路，旋转测量基\n",
                "    for depth in range(depth_DE):\n",
                "        cir.cnot()\n",
                "        cir.u3(param=theta_DE[depth])\n",
                "        \n",
                "    cir.rx(param=pi/2)\n",
                "    return cir"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### 2. 评估"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "- 计算测量结果 $m$ 的概率分布；\n",
                "- 计算估计器 $\\hat{\\phi}(m)=am$ 的 MSE，${\\rm MSE}=\\sum_m(\\hat{\\phi}(m)-\\phi)^2p_{\\theta}(m|\\phi)$；\n",
                "- 计算损失函数，此处我们利用离散形式的损失函数来近似其积分形式：\n",
                "\n",
                "$$\n",
                "C=\\sum_{k=1}^t\\frac{2}{t}f(\\phi_k){\\rm {MSE}}, \\tag{7}\n",
                "$$\n",
                "\n",
                "其中 $t$ 为选取区间内划分的份数（本教程中区间大小为 2），$f(\\phi_k)$ 为 $\\phi_k$ 对应的概率。"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 3,
            "metadata": {
                "ExecuteTime": {
                    "end_time": "2022-11-04T07:07:36.572763Z",
                    "start_time": "2022-11-04T07:07:36.559813Z"
                }
            },
            "outputs": [],
            "source": [
                "# 定义计算 m 的函数用于计算测量结果中 1 和 0 的个数差\n",
                "def calculate_m(num_qubits: int)-> List[int]:\n",
                "    m_list = []\n",
                "    for k in range(2**num_qubits):\n",
                "        k_bin = list(bin(k)[2:].zfill(num_qubits))\n",
                "        u = k_bin.count('1')\n",
                "        v = k_bin.count('0')\n",
                "        m = u - v\n",
                "        m_list.append(m)\n",
                "\n",
                "    return m_list\n",
                "\n",
                "\n",
                "def MSE(qnn: paddle.nn.Layer, phi: float) -> paddle.Tensor:\n",
                "    r\"\"\" 计算对应 phi 的 MSE\n",
                "    \n",
                "    Args:\n",
                "        cir: 拉姆塞干涉仪的变分电路\n",
                "        phi: 采样参数\n",
                "        a: 估计器的优化参数\n",
                "        \n",
                "    Returns:\n",
                "        phi 的均方误差\n",
                "    \n",
                "    \"\"\"\n",
                "    cir = RamseyCircuit(qnn.theta_EN, qnn.theta_DE, phi)\n",
                "    \n",
                "    # 测量\n",
                "    output_state = cir()\n",
                "    prob = Measure()(output_state)\n",
                "    \n",
                "    num_qubits = cir.num_qubits\n",
                "    m = calculate_m(num_qubits)\n",
                "    return sum([((phi - qnn.a * m[i]) ** 2) * prob[i] for i in range(2 ** num_qubits)])\n",
                "\n",
                "# 定义损失函数\n",
                "def loss_func(qnn: paddle.nn.Layer, sampling_times: int, mean: float, variance: float):\n",
                "    r\"\"\" 计算 QNN 模型的损失函数\n",
                "    \n",
                "    Args:\n",
                "        qnn: 一个 QNN 模型\n",
                "        sampling_times: 划分区间的个数\n",
                "        mean: 未知参数服从的正态分布的均值\n",
                "        variance: 未知参数服从的正态分布的方差\n",
                "    \n",
                "    \"\"\"\n",
                "    list_phi = [] # phi 的采样列表\n",
                "    list_pdf = [] # phi 的概率密度函数样本\n",
                "    for i in range(sampling_times):\n",
                "        phi = mean - 1 + (2 * i + 1)/ sampling_times # phi 的范围 [u - 1, u + 1]，每个 phi 取小区间端点处两个 phi 的均值       \n",
                "        prob = (1 / (((2 * pi) ** 0.5) * variance)) * exp(-((phi - mean) ** 2) / (2 * (variance**2)))  # phi 的概率密度函数\n",
                "        list_phi.append(phi)\n",
                "        list_pdf.append(prob)\n",
                "    \n",
                "    return sum([list_pdf[i] * MSE(qnn, list_phi[i]) * (2 / sampling_times) for i in range(sampling_times)])"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "### 3. 优化"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 4,
            "metadata": {
                "ExecuteTime": {
                    "end_time": "2022-11-04T07:07:36.588710Z",
                    "start_time": "2022-11-04T07:07:36.576756Z"
                }
            },
            "outputs": [],
            "source": [
                "def optimization(qnn: paddle.nn.Layer, num_itr: int, learning_rate: float) -> None:\n",
                "    r\"\"\" 对 QNN 模型进行优化\n",
                "    \n",
                "    Args:\n",
                "        qnn: 一个 QNN 模型\n",
                "        num_itr: 迭代次数\n",
                "        learning_rate: 学习速率\n",
                "    \n",
                "    \"\"\"\n",
                "    opt = paddle.optimizer.Adam(learning_rate=learning_rate, parameters=qnn.parameters())\n",
                "    print(\"训练开始：\")\n",
                "    for itr in range(1, num_itr):\n",
                "        loss = qnn()\n",
                "        loss.backward()\n",
                "        opt.minimize(loss)\n",
                "        opt.clear_grad()\n",
                "\n",
                "        if itr % 10 == 0:\n",
                "            print(\"     iter:\", itr, \"loss:\", \"%.4f\" % loss.numpy())"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 6,
            "metadata": {
                "ExecuteTime": {
                    "end_time": "2022-11-04T07:07:36.620687Z",
                    "start_time": "2022-11-04T07:07:36.608645Z"
                }
            },
            "outputs": [],
            "source": [
                "class RamseyInterferometer(paddle.nn.Layer):\n",
                "    r\"\"\" 变分拉姆塞干涉仪\n",
                "    \n",
                "    \"\"\"\n",
                "    def __init__(self) -> None:\n",
                "        super().__init__()\n",
                "        \n",
                "        # 为干涉仪添加参数\n",
                "        theta_EN = self.create_parameter(\n",
                "            shape= [depth_EN, N, 3], dtype=\"float64\",\n",
                "            default_initializer=paddle.nn.initializer.Uniform(low=0, high=2 * pi),\n",
                "        )\n",
                "        theta_DE = self.create_parameter(\n",
                "            shape= [depth_DE, N, 3], dtype=\"float64\",\n",
                "            default_initializer=paddle.nn.initializer.Uniform(low=0, high=2 * pi),\n",
                "        )\n",
                "        self.add_parameter('theta_EN', theta_EN)\n",
                "        self.add_parameter('theta_DE', theta_DE)\n",
                "        \n",
                "        # 添加对估计器的优化参数\n",
                "        a = self.create_parameter(\n",
                "            shape= [1], dtype=\"float64\",\n",
                "            default_initializer=paddle.nn.initializer.Uniform(low=0, high=2 * pi),\n",
                "        )\n",
                "        self.add_parameter('a', a)\n",
                "        \n",
                "    def forward(self) -> paddle.Tensor:\n",
                "        r\"\"\" 计算损失函数\n",
                "        \n",
                "        \"\"\"\n",
                "        return loss_func(self, TIMES, MEAN, VAR)\n",
                "    \n",
                "    def opt(self) -> None:\n",
                "        r\"\"\" 优化 QNN 模型\n",
                "        \n",
                "        \"\"\"\n",
                "        optimization(self, num_itr=ITR, learning_rate=LR)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": null,
            "metadata": {},
            "outputs": [],
            "source": [
                "N = 2  # 量子比特数\n",
                "depth_EN = 3  # 编码电路的层数\n",
                "depth_DE = 3  # 解码电路的层数\n",
                "LR = 0.2  # 基于梯度下降的优化方法的学习率\n",
                "ITR = 150   # 训练的总迭代次数\n",
                "TIMES = 30  # 划分参数区间的个数\n",
                "MEAN = 2  # 未知参数服从正态分布的均值\n",
                "VAR = 1  # 未知参数服从正态分布的方差"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 11,
            "metadata": {
                "ExecuteTime": {
                    "end_time": "2022-11-04T07:33:36.330577Z",
                    "start_time": "2022-11-04T07:29:01.098077Z"
                }
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "训练开始：\n",
                        "     iter: 10 loss: 5.6798\n",
                        "     iter: 20 loss: 2.3396\n",
                        "     iter: 30 loss: 1.1354\n",
                        "     iter: 40 loss: 0.8429\n",
                        "     iter: 50 loss: 0.4878\n",
                        "     iter: 60 loss: 0.3399\n",
                        "     iter: 70 loss: 0.2571\n",
                        "     iter: 80 loss: 0.2270\n",
                        "     iter: 90 loss: 0.2140\n",
                        "     iter: 100 loss: 0.2067\n",
                        "     iter: 110 loss: 0.2031\n",
                        "     iter: 120 loss: 0.2013\n",
                        "     iter: 130 loss: 0.2001\n",
                        "     iter: 140 loss: 0.1994\n"
                    ]
                }
            ],
            "source": [
                "QNN = RamseyInterferometer()\n",
                "QNN.opt()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "利用优化后的电路估计服从正态分布的参数 $\\phi$，绘制 MSE。"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 12,
            "metadata": {
                "ExecuteTime": {
                    "end_time": "2022-11-04T07:33:38.108968Z",
                    "start_time": "2022-11-04T07:33:36.333569Z"
                },
                "scrolled": true
            },
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 600x400 with 1 Axes>"
                        ]
                    },
                    "metadata": {
                        "needs_background": "light"
                    },
                    "output_type": "display_data"
                }
            ],
            "source": [
                "phi_list = []\n",
                "mse_list = []\n",
                "for i in range(TIMES):\n",
                "    phi = MEAN - 1 + (2 * i + 1) / TIMES\n",
                "    mse_est = MSE(QNN, phi)\n",
                "    phi_list.append(phi)\n",
                "    mse_list.append(mse_est)\n",
                "\n",
                "font = {'family': 'Times New Roman', 'weight':'normal', 'size':16}\n",
                "plt.figure(dpi=100)\n",
                "plt.plot(phi_list,mse_list,color='darkblue', linestyle='-')\n",
                "plt.scatter(phi_list,mse_list)\n",
                "plt.xlabel('$\\\\phi$',font)\n",
                "plt.ylabel('MSE',font)\n",
                "\n",
                "plt.grid()\n",
                "plt.show()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "## 结论"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "从图中可以看到，优化后的量子传感器（即量子电路）估计服从正态分布的参数的 MSE 与参数的概率密度呈负相关（MSE 与 $\\phi$ 的图像呈下凸型），且 MSE 在正态分布的均值（即 $\\mu$ 的取值）附近最低，说明在均值附近传感器估计参数的精度高，进一步说明通过变分的方式得到的传感器对该服从正态分布的参数有效。"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "---\n",
                "\n",
                "## 参考文献"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "[1] Braunstein S L, Caves C M. Statistical distance and the geometry of quantum states[J]. [Physical Review Letters, 1994, 72(22): 3439](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.72.3439).\n",
                "\n",
                "[2] Giovannetti V, Lloyd S, Maccone L. Quantum metrology[J]. [Physical review letters, 2006, 96(1): 010401](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.96.010401).\n",
                "\n",
                "[3] Tóth G, Apellaniz I. Quantum metrology from a quantum information science perspective[J]. [Journal of Physics A: Mathematical and Theoretical, 2014, 47(42): 424006](https://iopscience.iop.org/article/10.1088/1751-8113/47/42/424006/meta).\n",
                "\n",
                "[4] Marciniak C D, Feldker T, Pogorelov I, et al. Optimal metrology with programmable quantum sensors[J]. [Nature, 2022, 603(7902): 604-609](https://www.nature.com/articles/s41586-022-04435-4).\n",
                "\n",
                "[5] Giovannetti V, Lloyd S, Maccone L. Advances in quantum metrology[J]. [Nature photonics, 2011, 5(4): 222-229](https://www.nature.com/articles/nphoton.2011.35).\n",
                "\n",
                "[6] Kaubruegger R, Vasilyev D V, Schulte M, et al. Quantum variational optimization of Ramsey interferometry and atomic clocks[J]. [Physical Review X, 2021, 11(4): 041045](https://journals.aps.org/prx/abstract/10.1103/PhysRevX.11.041045)."
            ]
        }
    ],
    "metadata": {
        "kernelspec": {
            "display_name": "Python 3.7.13 ('py3.7_pq2.2.1')",
            "language": "python",
            "name": "python3"
        },
        "language_info": {
            "codemirror_mode": {
                "name": "ipython",
                "version": 3
            },
            "file_extension": ".py",
            "mimetype": "text/x-python",
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
            "version": "3.7.13"
        },
        "vscode": {
            "interpreter": {
                "hash": "4e4e2eb86ad73936e915e7c7629a18a8ca06348106cf3e66676b9578cb1a47dd"
            }
        }
    },
    "nbformat": 4,
    "nbformat_minor": 2
}
